home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Games / net3d-0.08 / util.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-22  |  3.3 KB  |  148 lines
  1. /* util.c
  2.  *
  3.  * Miscellaneous functions used by both the client and server
  4.  */
  5. #include "net3d.h"
  6.  
  7. /* caches for jsin and jcos calls */
  8. static struct cache *sc;
  9. static struct cache *cc;
  10. #define SCSIZE 5
  11. #define CCSIZE 5
  12.  
  13. /* data on cache efficiency */
  14. int sincalls=0;
  15. int sincachehits=0;
  16.  
  17. /* Returns the vehicle that va has collided with, drawn from the
  18.  * vehicle list given by vh, or NULL if no collision.
  19.  */
  20. struct vehicle *collide(struct vehicle *va, struct vehicle *vh)
  21. {
  22. struct vehicle *vb;
  23.  
  24. /* Vehicles that are shrapnel, scenery or seedpods, or are already dead
  25.  * cannot collide with anything.
  26.  */
  27. if (va->type == t_shrapnel || va->type == t_scenery || va->type == t_seedpod ||
  28.  va->hp < 0)
  29.     return NULL;
  30.  
  31. /* Loop through all other vehicles, looking for a collision.
  32.  */
  33. for(vb=vh; vb; vb=vb->next) {
  34.     /* Once again, prevent collisions with scenery, shrapnel, seedpods
  35.      * or dead vehicles waiting to be freed.
  36.      */
  37.     if (vb->type == t_shrapnel || vb->type == t_scenery ||
  38.      vb->type == t_seedpod || vb->hp < 0)
  39.         continue;
  40.  
  41.     /* Also prevent collisions between a vehicle and itself, collisions
  42.      * with a vehicle's own ammo, and collisions between bullets.
  43.      */
  44.     if (va == vb || va->firer == vb || vb->firer == va ||
  45.      (va->type == t_bullet && vb->type == t_bullet))
  46.         continue;
  47.  
  48.     /* now actually compare bounding boxes.. */
  49.     if ((va->bmin.x>=vb->bmin.x && va->bmin.x<=vb->bmax.x) ||
  50.      (va->bmax.x>=vb->bmin.x && va->bmax.x<=vb->bmax.x)) {
  51.       if ((va->bmin.y>=vb->bmin.y && va->bmin.y<=vb->bmax.y) ||
  52.        (va->bmax.y>=vb->bmin.y && va->bmax.y<=vb->bmax.y)) {
  53.         if ((va->bmin.z>=vb->bmin.z && va->bmin.z<=vb->bmax.z) ||
  54.          (va->bmax.z>=vb->bmin.z && va->bmax.z<=vb->bmax.z)) {
  55.     /* we have a collision!
  56.      */
  57.           return vb;
  58.           }
  59.         }
  60.       }
  61.     }
  62.  
  63. /* no collisions were found */
  64. return NULL;
  65. }
  66.  
  67. /* find the vehicle with id given by vid, in the list pointed to by
  68.  * vhead.
  69.  */
  70. struct vehicle *findbyvid(struct vehicle *vhead, int vid)
  71. {
  72. struct vehicle *vp;
  73.  
  74. for(vp = vhead; vp && vp->vid != vid; vp=vp->next)
  75.     ;
  76. return vp;
  77. }
  78.  
  79. void initcaches(void)
  80. {
  81. sc = (struct cache *)calloc(SCSIZE,sizeof(struct cache));
  82. cc = (struct cache *)calloc(CCSIZE,sizeof(struct cache));
  83. }
  84.  
  85. double jsin(double a)
  86. {
  87. int i;
  88. register int oldest;            /* best place to put the new value */
  89. register long lowesttime;
  90. static long call=1;
  91.  
  92. sincalls++;
  93. call++;
  94. lowesttime = call;
  95. /* first, check the cache to see if the value is already in */
  96. for(i=0; i<SCSIZE; i++) {
  97.     if (sc[i].inuse && sc[i].val == a) {
  98.         /* found in the cache! */
  99.         sincachehits++;
  100.         return sc[i].res;
  101.         }
  102.     if (!sc[i].inuse) {
  103.         /* this cache line is empty.. use it */
  104.         oldest = i;
  105.         lowesttime = 0;
  106.         }
  107.     if (sc[i].lastused < lowesttime) {
  108.         /* this is the oldest one found so far */
  109.         lowesttime = sc[i].lastused;
  110.         oldest = i;
  111.         }
  112.     }
  113.  
  114. /* the value wasn't found... store it in the cache */
  115. sc[oldest].val = a;
  116. sc[oldest].inuse = true;
  117. sc[oldest].lastused = call;
  118. return (sc[oldest].res = sin(a));
  119. }
  120.  
  121. struct object *findturret(struct vehicle *v)
  122. {
  123. int i;
  124.  
  125. for(i=0; i<v->partcount; i++)
  126.     if (v->parts[i]->turret)
  127.         return v->parts[i];
  128. return NULL;
  129. }
  130.  
  131. void addpts(struct point p1, struct point p2, struct point *ret)
  132. {
  133. ret->x = p1.x + p2.x;
  134. ret->y = p1.y + p2.y;
  135. ret->z = p1.z + p2.z;
  136. }
  137.  
  138. #if NO_STRERROR
  139. char *strerror(int e)
  140. {
  141. static char buf[100];
  142.  
  143. sprintf(buf,"error %d",e);
  144. return buf;
  145. }
  146. #endif
  147.  
  148.